
//measureSegmentPart()
//参数：incision:需要切割单元格内容为true,否为false. 切分表示当前页面容量，无法容纳整行单元格。高度不足；
//page_segment:页面剩余容量
//cell_width:  单元格宽度
//cell_height: 单元格高度，逐行输出时判断边界高度
//dist_pages_position_start_x: 目标页面起始位置x
//dist_pages_position_start_y: 目标页面起始位置y
//sour_canvas_position_start_x: 源画布起始位置x
//sour_canvas_position_start_y: 源画布起始位置y
function measureSegmentPart(
    incision,
    page_segment,    
    cell_width,
    cell_height,
    dist_pages_position_start_x,
    dist_pages_position_start_y,
    sour_canvas_position_start_x,
    sour_canvas_position_start_y,
    cellObj

) {
   
    
    //console.log("QQ:523==============启动新计划了3点起，8点走=============================");
    let last_page_segment=page_segment;//985-dist_pages_position_start_y%985; //当前页面容量
    hasNoEnoughSpacing=false;//标识当前页有没有足够的空间容纳表格首行文本
    spacingDeviation=0;//页面换行文字高偏差补偿
    totalCellHeight=0;//重新置0
    totalParaSegmentHeight=0;//自然代高度
    maxTextHeight=0;
    upstairs_text_lineHeight=0;
    Hc=cell_height ;  //当前单元格高度
    moveToNextPage=false;
    var textHeight=18;
    
    extHeightFlag=false;
   
    let totalTextHeight = 0;
    let eachLineMaxHeight =0;
    let lineSpacing=0;
    cells_Source_Height=0;   //临时绘制单元格有效高度累计,是文字一行输出后的Y轴的坐标，每输出 一行就要将当前字体大小加行间距一起算进来.
    cells_Dist_Start_Y=0;    //目标页面起始全局坐标.
    if (hadGen == 0) {
        generateLinesData();
        hadGen = 1; // 确保generateLinesData只被调用一次，除非有更新
    }


    if(showParaInCellEdit===true)
        {
            //console.log(`%cQQ:1112 showParaInCellEdit::${showParaInCellEdit}`,'color:green');
        }
    cellsCtx.fillStyle ="transparent";// '#FFFFFF'; // 白色
    cellsCtx.fillRect(0, 0, cellsCanvas.width, cellsCanvas.height); // 填充整个画布

    cellsCtx.clearRect(0, 0, cellsCanvas.width, cellsCanvas.height); // 清除画布，准备新的渲染

    if(linesData==null)
    {
        //console.log("C4 renderText linesData.length<=0  ");
        //console.log(`%cQQ:1112 showParaInCellEdit::${showParaInCellEdit} linesData==null`,'color:red');
        return ;

    }

    // const cellObj = {                          
    //     segmentHeight:tableObj.restOffCurrentPageSpace, //当前页面可用空间                         
    //     max_text_height_in_cell:0,                      //已结绘制偏移
    //     finish_draw:false ,                             //绘制结束
    //     rows,                                           //行号
    //     columns,                                        //列号
    //     position_offset_y;                              //页面偏移
    //     found_position_section:false                    //如果没有打到单元格切片为false,在本行其它单元格续继扫描。
    // };

   
    // 计算整体文本高度
    cellObj.max_text_height_in_cell+=1;
    segmentHeight=cellObj.segmentHeight;
  
     totalTextHeight = 0;
     lineSpacing=  textData.lineSpacing;
    //当前行字符串不为0 逐行输出文字
        if(linesData.length>0) 
        {
          
            totalTextHeight = linesData[linesData.length - 1].y + linesData[linesData.length - 1].maxHeight;
        }   
   

        if(inMeasureAction==1 )//&&debugSN=="Tab001"
        console.log(`%c QQ:527 新单元格绘制开始: linesData[linesData.length - 1].maxHeight:${linesData[linesData.length - 1].maxHeight} segmentHeight:${cellObj.segmentHeight}  \
        inMeasureAction:${inMeasureAction} debugSN: ${debugSN} cell_height:${cellObj.table_cell_height}  \
        scan_Global_RowOfTable:${ cellObj.rows } current_columns_index:${cellObj.columns}  totalTextHeight:${totalTextHeight}  \
        position_offset_y:${cellObj.position_offset_y} position_offset_y%985:${cellObj.position_offset_y%985} `,"color:green");

       
    maxTextHeight=totalTextHeight>maxTextHeight?totalTextHeight:maxTextHeight;
    //自然段的首行字符串无法在当前页面显示，标识自动在下一页进行绘制
    console.log(`%c QQ:527 cellObj.max_text_height_in_cell: ${cellObj.max_text_height_in_cell}  在measureSegment要取单元格最大高 排除字符被切`, "color: green; background-color: yellow;");
    if(totalTextHeight>last_page_segment)
    {
       // console.log("QQ:523:",maxTextHeight," 页面可容部分空间segmentHeight:",last_page_segment," showParaInCellEdit:",showParaInCellEdit);
        if(maxTextHeight>segmentHeight)
        {
            console.log(`%cQQ:527 可能要跳到下一页哦 maxTextHeight:${maxTextHeight} segmentHeight:${segmentHeight}`,"color:red");
            //TODO: 2024-5-23 4:16 待处理此种情况
            
        }
        
    }
    else
    {
        console.log(`%c QQ:527 可以放得下什么？？？`, "color: green; background-color: yellow;");
    }

       
    // 根据垂直对齐方式计算起始Y坐标偏移
    let startYOffset = 0;
    if (textData.verticalAlign === 'middle') {
        startYOffset = (cellsCanvas.height - totalTextHeight) / 2;
    } else if (textData.verticalAlign === 'bottom') {
        startYOffset = cellsCanvas.height - totalTextHeight;
    }

    if(showParaInCellEdit===true)
    {
            //console.log(`%cQQ:1112 lineSpacing:${lineSpacing}`,'color:red');
    }



//切割辅助标记
//下一段切割
var paraNextSegmentPosition=0;  //记录切割位置
let segment_index=0;//切割索引
let remainingHeight=0;//


// 对于顶部对齐，startYOffset保持为0
for (let lineIndex = 0; lineIndex < linesData.length; lineIndex++) {
    let line = linesData[lineIndex];
    //let cursorX = 0; // 每行的起始X坐标
    let maxAscent = 0;
    let maxDescent = 0;
    let lineNo=0;
    let wavyLineStart = null; // 用于记录波浪线起始位置
    let wavyLineColor = "black"; // 默认波浪线颜色
    let cursorX = line.cursorX!==undefined?line.cursorX+textArea_offsetX:textArea_offsetX; // 使用每行特定的cursorX开始渲染
    if(lineIndex==0)
        temp_show_line_Text=line.text;

    
    if (textData.horizontalAlign === 'center') {
        //console.log("C4 horizontalAlign center line.lineWidth: ",line.lineWidth);
        cursorX = (cellsCanvas.width - line.lineWidth) / 2;
    } else if (textData.horizontalAlign === 'right') {
        cursorX = cellsCanvas.width - line.lineWidth;
        //console.log("C4 horizontalAlign center line.right: ",line.lineWidth);
    }


    //console.log("C4 cursorX:",cursorX);
    // 首先，遍历一次以找出每行最大的ascent和descent
    for (let i = 0; i < line.text.length; i++) {
        const charIndex = i + line.startIndex;
        const charStyle = findCharStyle(charIndex);
        cellsCtx.font = `${charStyle.bold ? 'bold ' : ''}${charStyle.italic ? 'italic ' : ''}${charStyle.fontSize}px ${charStyle.font}`;
        const metrics = cellsCtx.measureText(line.text[i]);
        maxAscent = Math.max(maxAscent, metrics.actualBoundingBoxAscent);
        maxDescent = Math.max(maxDescent, metrics.actualBoundingBoxDescent);
      
    }   

        //let baseLineY = line.y + maxAscent; // 使用最大ascent来调整基线，确保垂直对齐
        //textArea_offsetY 在单元格Y轴方向上偏移,避免与边框重叠

        // 获取文本高度
        textHeight = maxAscent + maxDescent;
        const baseLineY = line.y + startYOffset+ maxAscent+ textArea_offsetY; // 调整y坐标，基于垂直对齐偏移
        //const topLineY=line.y+startYOffset+maxAscent;//文字的起始位置线
        const topLineY=line.y+startYOffset+maxAscent- textArea_offsetY;//文字的起始位置线
        currentLineMaxHeight=0;
        // 然后，实际渲染每个字符
         lineNo=lineIndex;
        for (let i = 0; i <= line.text.length; i++) {
            let char = '';          
            if(i<line.text.length)
            char=line.text[i];
            const charIndex = i + line.startIndex;
            const charStyle = findCharStyle(charIndex);
            cellsCtx.font = `${charStyle.bold ? 'bold ' : ''}${charStyle.italic ? 'italic ' : ''}${charStyle.fontSize}px ${charStyle.font}`;
            eachLineMaxHeight=Math.max(eachLineMaxHeight,parseInt(charStyle.fontSize));
            cellsCtx.fillStyle = charStyle.color;
            const metrics = cellsCtx.measureText(char);     
            // 绘制字符
            // 继续使用字符的前景色绘制字符
            cellsCtx.fillStyle = charStyle.color;
            cellsCtx.fillText(char, cursorX, baseLineY);
            //console.log("最大行高：",currentLineMaxHeight);  
            cells_charWidths[i] = { width: metrics.width, x: cursorX };
            cursorX += metrics.width;
        }

        dist_copy_cell_height=cell_height;      
                 //3.1.2是首行？
                if(cellObj.rows==0)//表格单元格首行
                {
                        //3.1.2.1 是! 能容下首行字符串
                          //当前页的剩余容量与当前文字高度相比 可得出 首行文字是否可放得下
                       if(lineIndex==0)
                        {       //当前页面可以容纳第一行内容
                                if(cellObj.segmentHeight>textHeight)
                                {   
                                       tempSegmentPosition=baseLineY+maxDescent;
                                     
                                       first_line_text_height=tempSegmentPosition+cellObj.spacing_height;
                                        cells_source_offset_rest_page=textHeight;//3.1.2.1.1计算出剩下容量，作为偏移; 即记录上一次最大的首行单元格文字行可容的位置 
                                        cells_Source_Height+=textHeight+cellObj.spacing_height;                       //保留最近一行段落行距;//计算每行文字输出后的和
                                        if(inMeasureAction==1 )
                                        {
                                            //columns 吃藕撸面能分列
                                            console.log(`%c QQ:527 debug:${debugSN} 行:${lineNo} 列:${cellObj.columns}  首行放得下文字首行: textHeight${textHeight}  segmentHeight:${segmentHeight} ;cell_height:${cellObj.table_cell_height} tempSegmentPosition(单行文字占位高):${tempSegmentPosition} ; cellsIndex:${current_columns_index}   text:${line.text}`,"color:blue");
                  
                                        }
                                   
                                    
                                }
                                else
                                {
                                    hasNoEnoughSpacing=true;
                                    if(inMeasureAction==1&&debugSN=="Tab001" )
                                        {
                                            console.log(`%c QQ:527 debug:${debugSN} 行:${lineNo} 列:${cellObj.columns}  首行放不下文字首行: textHeight${textHeight} segmentHeight:${segmentHeight} ;cell_height:${cellObj.table_cell_height} tempSegmentPosition(单行文字占位高):${tempSegmentPosition} ; cellsIndex:${current_columns_index}   text:${line.text}`,"color:blue");
                  
                                        }
                                    if(inMeasure) //表格首行不够位置，，标为空间不够，以便跳页
                                       return;

                                }
                           
                           //可以放得下首行表格内的首行字符串, 什么也不用做;
                        }
                        else
                        {   //非首行字符绘制
                            console.log(`%c QQ:527 debug:${debugSN} 行:${lineNo} 列:${cellObj.columns}  非首行绘制`,"color:red");
                            //3.1.2.1.1计算出剩下容量，作为偏移offset_rest_page
                            // 切割信息
                            // A:从哪里取，起始位置多少，取多高，多宽？
                            // 1. 起始坐标:  cells_Source_Start_X/Y;
                            // 2. 高度:         cells_Source_Height;
                            // 3. 宽度:         cells_Source_Width;

                            // B:取到之后放到哪里去？
                            // 1. 起始坐标：cells_Dist_Start_X/Y;  通过页面大小，可以计算出所在页；
                            // 2. 高度：      cells_Dist_Height;
                            // 3. 宽度：      cells_Dist_Width;

                            // C: 切割类型 cut_type：0 首行不足，跳页；
                            //                     1 横切，要补首尾线；
                            // D: 对像类别 paraType：0 自然段，1 表格

                                if(lineIndex!=0)
                                {
                                    lastSegmentPosition=current_cell_position_y ;
                                    cells_Dist_Start_Y=current_cell_position_y;
                                    cells_Dist_Height=cells_Source_Height;
                                    cells_Dist_action=1;//1表示页尾不足，写完要跳转一新页

                                    //measureSegment()
                                    //参数：incision:需要切割单元格内容为true,否为false. 切分表示当前页面容量，无法容纳整行单元格。高度不足；
                                    //cell_width:  单元格宽度
                                    //cell_height: 单元格高度，逐行输出时判断边界高度
                                    //dist_pages_position_start_x: 目标页面起始位置x
                                    //dist_pages_position_start_y: 目标页面起始位置y
                                    //sour_canvas_position_start_x: 源画布起始位置x
                                    //sour_canvas_position_start_y: 源画布起始位置y


                                    //页面与表格单元格绘制规则模型
                                    //***************************************************/
                                    // var Hp=985; //页面高度
                                    // var Hct=0;  //下半页单元格累计高度  Hct<=Hp
                                    // var Hc=0 ;  //当前单元格高度
                                    // var Hs=0 ;  //上半截单元格高度（当一页容不下一行单元格时）
                                    // var Ha=0 ;  //Ha=Hc-Hs
                                    // var Has=0;  //下半截页面可用高度
                                    //***************************************************/
                                    Hs=cells_Source_Height;//记住上半截单元格高度
                                    Hct=Hs;
                                    if(inMeasureAction==1)
                                    {         

                                        console.log(`%c QQ:527  这里发生切割debugSN:${debugSN} lineNo:${lineNo} dist_pages_position_start_y:${cellObj.position_offset_y} sour_canvas_position_start_y:${sour_canvas_position_start_y} cells_Source_Height:${cells_Source_Height} segmentHeight:${segmentHeight} ;current_tables_canvas_drawing_position_y:${current_tables_canvas_drawing_position_y} 上一行的高:${cells_source_offset_rest_page}  text:${line.text}`,"color:blue");
                                    }

                                    //5-23切割要记录的内容：
                                    //1.形成当前的切块，包括两部分数据，1是拷贝源 的起始与高度；2是目标源的起始坐标与高度；
                                    //2.记录最后一次拷贝源, 目标源 分别的结束位置。将做来下一次分块的起点位置.
                                    //3. 由于两都高度是一样的，只需要一个source_copy_block_height来表示即可。
                                    //4. 保存最后一个单元格高度
                                    //重新定义 这个坐标为全局绝对坐标，包括页面偏移： 
                                    // var source_copy_start_position_y=0;
                                    // var source_copy_block_height=0;
                                    // var dist_copy_start_position_y=0;
                                    // var dist_copy_cell_height=0;
                                    
                                                              

                                     var newSegment1 = {

                                        segment_index: 0,
                                        inMeasure:inMeasure,
                                        debugSn:debugSN,
                                        cells_Dist_Start_Y:cellObj.position_offset_y,
                                        cells_Dist_Height:cells_Dist_Height,
                                        cells_Source_Start_Y:current_tables_canvas_drawing_position_y,
                                        sliceType:1,
                                        offset_X: 0,
                                        offset_Y: lastSegmentPosition,
                                        width: 700,
                                        height: cells_Source_Height,
                                        pageOffsetY:segmentHeight,
                                        lineText:line.text,
                                        dataSource:"切割开1:判断一个首行单元格的字符是否能被完整显示，如果不能，再判断这个表格高度是否小于一个页面985"
                                        
                                        };
                                                               // segment_Info.push(newSegment1);
                                
                                        checkDuplicateAndInsert(segment_Info, newSegment1);

                                    //5-23 当切块发生变化时，更新源与目标源的偏移
                                    source_copy_block_height=cells_Dist_Height;
                                    source_copy_start_position_y+=source_copy_block_height;
                                    dist_copy_start_position_y+=source_copy_block_height;

                                    current_tables_canvas_drawing_position_y+=cells_Source_Height;
                                    offsetHeaderLine=baseLineY;
                                    //moveToNextPage=true;
                                    break;
                                }
                                                          
                        }

                }
                else//3.1.2 非首行
                {   
                    //3.1.2.2 否! 获取当前页面空间及文本高
                    if(inMeasureAction==1&&debugSN=="Tab001" )
                        console.log(`%c QQ:527  非首行单元格 segmentHeight:${segmentHeight} row:${scan_Global_RowOfTable} ; cellsIndex:${current_columns_index} text:${line.text}`,"color:red");

                        if(segmentHeight>(textHeight))
                        {   
                               tempSegmentPosition=baseLineY+maxDescent;
                               let myLast_Source_height=cells_Source_Height;//保存临时上一行的高度，如果出现超页，就会用之前这个数据。。

                                cells_source_offset_rest_page=textHeight;//3.1.2.1.1计算出剩下容量，作为偏移; 即记录上一次最大的首行单元格文字行可容的位置 
                                cells_Source_Height+=textHeight+lineSpacing;//计算每行文字输出后的和
                                    if(cells_Source_Height<segmentHeight)
                                    {  
                                        lastSegmentPosition+=textHeight+lineSpacing;
                                        if(inMeasureAction==1&&debugSN=="Tab001" )
                                            {
                                                console.log(`%c QQ:527  非首行放得-------下文字首行line:${lineNo} cells_Source_Height:${cells_Source_Height} segmentHeight:${segmentHeight} ;cell_height:${cellObj.table_cell_height} tempSegmentPosition:${tempSegmentPosition} ; cellsIndex:${current_columns_index}`,"color:blue");
                      
                                            }

                                    }
                                    else
                                    {
                                        if(inMeasureAction==1 )
                                            {
                                                console.log(`%c QQ:527  非首行放不下所有文字 本页表格列高:${dist_total_cells_height+myLast_Source_height} current_tables_canvas_drawing_position_y:${current_tables_canvas_drawing_position_y} dist_total_cells_height:${dist_total_cells_height} cells_Dist_Start_Y:${cells_Dist_Start_Y} pageGlobalYPosition${pageGlobalYPosition} debugSN:${debugSN} cells_Source_Height:${myLast_Source_height} line:${lineNo} line.text${line.text} cells_Source_Height:${cells_Source_Height} segmentHeight:${segmentHeight} ;cell_height:${cellObj.table_cell_height} tempSegmentPosition:${tempSegmentPosition} ; cellsIndex:${current_columns_index}`,"color:blue");
                      
                                            }

                                
                                               
                                                if(inMeasure) //表格首行不够位置，，标为空间不够，以便跳页
                                                return;
                                    }
                              
                           
                            
                        }
                        else
                        {
                           
                           // lastSegmentPosition=current_cell_position_y ;
                            cells_Dist_Start_Y=current_cell_position_y;
                            cells_Dist_Height=cells_Source_Height;
                            cells_Dist_action=1;//1表示页尾不足，写完要跳转一新页
                            is_on_bottom_of_page=true;//表示页尾不足，绘制完成后要做补偏页面起点
                             if(inMeasureAction==1 )
                                {                                            
                                 console.log(`%c QQ:527  非首行单元格这里发生切割: cells_Dist_Start_Y:${cells_Dist_Start_Y} cells_Source_Height:${cells_Source_Height} segmentHeight:${segmentHeight} ;current_tables_canvas_drawing_position_y:${current_tables_canvas_drawing_position_y} 上一行的高:${cells_source_offset_rest_page}`,"color:blue");
                                }
                            
                           

                             var newSegment1 = {
                                                        segment_index: 0,
                                                        inMeasure:inMeasure,
                                                        debugSn:debugSN,
                                                        cells_Dist_Start_Y:cells_Dist_Start_Y,
                                                        cells_Dist_Height:cells_Dist_Height,
                                                        cells_Source_Start_Y:current_tables_canvas_drawing_position_y,
                                                        sliceType:1,
                                                        offset_X: 0,
                                                        offset_Y: lastSegmentPosition,
                                                        width: 700,
                                                        height: cells_Source_Height,
                                                        pageOffsetY:segmentHeight,
                                                        lineText:line.text,
                                                        dataSource:"切割开12:判断一个首行单元格的字符是否能被完整显示"
                                                       
                                                        };
                                                       // segment_Info.push(newSegment1);
                        
                                                        checkDuplicateAndInsert(segment_Info, newSegment1);
                                                        current_tables_canvas_drawing_position_y+=cells_Source_Height;
                            
                       
                            if(inMeasure) //表格首行不够位置，，标为空间不够，以便跳页
                               return;

                        }

                }
            
            

       

            if(inMeasureAction==1)
            {
              console.log(`%c QQ:527 debug${debugSN} 第一页容量可以放行下部分:${985-cellObj.position_offset_y%985 } 行距:${cellObj.spacing_height} 文字高:${tempSegmentPosition} 单元格首行使用高度:${first_line_text_height}\
             本列高还有另一下半部高: ${cellObj.table_cell_height-first_line_text_height}`,'color:red');
            }
        cellObj.compensating_height=cellObj.table_cell_height-first_line_text_height;
        //绘制完一行后，需要判断是否需要切割单元格
        //如果需要切割单元格，则需要记录当前单元格的起始位置和高度
        //console.log("QQ:111 观察单元格:",single_table_cell_index," text_line_height:",currentLineMaxHeight);
        if((baseLineY+maxDescent+lineSpacing)>=segmentHeight)//baseLineY在当前行内，需要截断
        {
            //切割开2:超过segmentHeight
                // if((tempSegmentPosition+lineSpacing*2)>maxTextHeight)
                // {
                     console.log(`%c QQ:527--------------------------: 正在输出的文本高超过了 容量 全文高度:",${tempSegmentPosition}," ${showParaInCellEdit}:",${showParaInCellEdit}`,"color:blue");
                // }
                 paraNextSegmentPosition=baseLineY+maxDescent;//记录还没有被切的单元格的高度
                if(showParaInCellEdit==true)
                {
                    //这里要计算了出补偿量
                    totalParaSegmentHeight=maxTextHeight;
                   
                    lastSegmentPosition=tempSegmentPosition;
                    //console.log(`%c QQ:1115  ,upstairs_cells_height:${upstairs_cells_height} 理想切割点YPosition:${985-tempSegmentPosition} , 当前光标位置:${tempSegmentPosition},segmentHeight：${segmentHeight} 光标位置+文字高+换行间隙：${tempSegmentPosition+lineHeight+lineSpacing} paraNextSegmentPosition:${paraNextSegmentPosition}`,"color:red");
                    //console.log("QQ:1115: 正在输出的文本高超过了 容量 全文高度:",maxTextHeight," SN:",debugSN," paraNextSegmentPosition:",paraNextSegmentPosition," 第一页面可容部分空间segmentHeight:",segmentHeight," 完整切割文高:"+tempSegmentPosition," baseLineY+maxDescent:", baseLineY+maxDescent," showParaInCellEdit:",showParaInCellEdit," line:",line.text);

                       if(lastSegmentPosition>0)
                        {
                            if(spacingDeviation==0)
                             spacingDeviation+=segmentHeight-tempSegmentPosition;
                          
                            var newSegment1 = {
                                segment_index: 0,
                                inMeasure:inMeasure,
                                sliceType:0,
                                debugSn:debugSN,
                                cells_Dist_Start_Y:cells_Dist_Start_Y,
                                cells_Dist_Height:cells_Dist_Height,
                                offset_X: 0,
                                offset_Y: 985-tempSegmentPosition,
                                width: 701,
                                height: tempSegmentPosition,
                                pageOffsetY:segmentHeight,
                                dataSource:"切割开2 : 超过segmentHeight "
                                };
                               // segment_Info.push(newSegment1);

                            let myCheck=    checkDuplicateAndInsert(segment_Info, newSegment1);
                              
                             
                              if(!myCheck)
                                {     //console.log(`%c QQ:1115  理想切割点:${tempSegmentPosition} myCheck:${myCheck} `, "color:green");
                                      segmentHeight=985; //下一页的容量是
                                      cellObj.max_text_height_in_cell=0;
                                      tempSegmentPosition=0;
                                }

                        }
                }
      
        }
        else //segmentHeight>baseLineY+maxDescent 正常区域内
        {
          
            tempSegmentPosition=baseLineY+maxDescent+cellObj.spacing_height;
           
            //如果此时tempSegmentPosition已经超过了最大高度，则需要切割单元格  
            //为下一页的单元格内容做准备
            //计算出剩余的内容高度
            remainingHeight=maxTextHeight-tempSegmentPosition; 
            cellObj.compensating_height=cellObj.table_cell_height-tempSegmentPosition;
            console.log(`%c Q:527: 逐行到放不下为止 此时：debug:${debugSN} 行:${lineNo} 列:${cellObj.columns}  全文高度:${maxTextHeight},行距:${cellObj.spacing_height} 第一页面可容部分空间segmentHeight:${segmentHeight}, 完整切割文高:${tempSegmentPosition}, upstairs_cells_height:${upstairs_cells_height}, 实际高度:${upstairs_cells_height+tempSegmentPosition}, index: ${segment_index}, line:${line.text} ;where to call:${where_to_call}`,"color:blue");
            //" 实际高度:",upstairs_cells_height+tempSegmentPosition
            //" 完整切割文高:"+tempSegmentPosition
            cellObj.found_position_section=true; //标识找到切口位置
            cellObj.max_text_height_in_cell=tempSegmentPosition;//切口高度
            cellObj.last_max_text_height_in_cell=cellObj.max_text_height_in_cell;
            cellObj.is_on_bottom_of_page=true;
         
            segment_index+=tempSegmentPosition;
          
        }
        let underLineM=baseLineY+lineSpacing;
       

        //drawWavyUnderline(wavyLineStart, underLineM, cursorX - wavyLineStart, "green");
        //drawWavyUnderline(wavyLineStart, topLineY-lineSpacing, cursorX - wavyLineStart, "black");

        //判断是不是最后一行，如果是最后一行，不要行距。
        let totalLines=linesData.length;
        if(lineIndex<totalLines-1)
        totalCellHeight=totalCellHeight+ eachLineMaxHeight+textData.lineSpacing;
         else 
        totalCellHeight=totalCellHeight+eachLineMaxHeight+textArea_offsetY; //加上顶行


      
            // 行末处理，确保波浪线被绘制
            if (wavyLineStart !== null) {
                const underlineY = baseLineY + 5; // 基线下方的Y坐标
                drawWavyUnderline(wavyLineStart, underlineY, cursorX - wavyLineStart, underlineColor);
            }
};


       if(hasToCutCells==true)
        {
            cellsCompareData.push({
                textHeight: totalTextHeight,
                segmentHeight: segmentHeight,
                cellsHeight: tempSegmentPosition,
                columnsIndex: current_columns_index
            });
            //console.log("QQ5: cellsHeight",tempSegmentPosition," segmentHeight:",segmentHeight);

        }


//console.log("段落总高度：",totalCellHeight," 画布高：",cellsCanvas.height);
if(totalCellHeight>cellsCanvas.height) {
    extHeightFlag=true;

    var messageToSend = "这是一条通过事件总线传递的消息";
    if(lastMessage!=totalCellHeight)
    {
        EventBus.trigger("customMessage", totalCellHeight);
        lastMessage=totalCellHeight;//消息生产

    }
   

}
}
